Parallel encoder for low-density parity-check (LDPC) codes

ABSTRACT

A low-density parity check (LDPC) encoder that calculate parity check values for a message using an LDPC parity check matrix is provided. A matrix-vector multiplication unit is operative to multiply a portion of the LDPC parity check matrix and the message to obtain an intermediate vector. A parallel recursion unit is operative to recursively calculate a first plurality of parity check values for the message based on the intermediate vector and to recursively calculate a second plurality of parity check values for the message based on the intermediate vector. The first plurality of parity check values are calculated in parallel with the second plurality of parity check values.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No.13/090,642, filed Apr. 20, 2011 (now U.S. Pat. No. 8,539,304), whichclaims the benefit under 35 U.S.C. §119(e) of U.S. ProvisionalApplication No. 61/328,562, filed Apr. 27, 2010.

This application is also related to U.S. application Ser. No. 12/187,858(now U.S. Pat. No. 8,196,010), filed Aug. 7, 2008.

Each of these prior applications are hereby incorporated by referenceherein in their entirety.

BACKGROUND OF THE DISCLOSURE

The disclosed technology relates generally to data encoding, and moreparticularly to low-density parity check (LDPC) encoders.

With the continuing demand for high-reliability transmission ofinformation in digital communication and storage systems, and with therapid increase in available computational power, various coding anddecoding techniques have been investigated and applied to increase theperformance of these systems. One such coding technique, low-densityparity check (LDPC) coding, was first proposed in the 1960s, but was notused until the late 1990s when researchers began to investigateiterative coding and decoding techniques.

LDPC codes are systematic block codes which have a very sparse paritycheck matrix. A sparse parity check matrix contains mostly ‘0’ entrieswith only relatively few ‘1’ entries. In a sparse parity check matrixonly a very small number of message bits participate in any given paritycheck. LDPC codes can be regular or irregular. When the number ofmessage bits in each parity check is the same, the LDPC codes are saidto be regular. Otherwise they are said to be irregular.

The IEEE Std 802.11n™-2009 of wireless local area network (WLAN)standards allow for the use of LDPC codes as an optional mode. The IEEEStd 802.11n™-2009 standards are incorporated herein in their entirety.The LDPC codes proposed for the IEEE 802.11n standards are irregularLDPC codes. There are three LDPC block lengths in the IEEE 802.11nstandards: 648, 1296, and 1944 bits. The number of parity check bits forthese LDPC codes depends on the coding rate.

There are a few concerns with LDPC codes. The error floor of LDPC codesmay be of particular concern; in several applications, low error floorsare required. However, it may be difficult to implement a low errorfloor LDPC code without making the code block length large. Lengthy LDPCcodes, on the other hand, may require large memory buffers and/orcomputational power, even though the parity-check matrix is sparse. Dueto the potentially large memory and computational requirements ofsuitably powerful LDPC encoders, the latency of these LDPC encoders istypically greater than desired.

SUMMARY

An embodiment of a low-density parity check (LDPC) encoder calculatesparity check values for a message using an LDPC parity check matrix. Amatrix-vector multiplication unit is operative to multiply a portion ofthe LDPC parity check matrix and the message to obtain an intermediatevector. A parallel recursion unit is operative to recursively calculatea first plurality of parity check values for the message based on theintermediate vector and to recursively calculate a second plurality ofparity check values for the message based on the intermediate vector.The first plurality of parity check values are calculated in parallelwith the second plurality of parity check values.

An embodiment of a method and apparatus for calculating parity checkvalues for a message uses a low-density parity check (LDPC) code. Aproduct of a portion of an LDPC parity check matrix and the message arecalculated, in an LDPC encoder, to obtain an intermediate vector. Afirst plurality of parity check values for the message are recursivelycalculated based on the intermediate vector. A second plurality ofparity check values for the message are recursively calculated based onthe intermediate vector. The first plurality of parity check values arecalculated in parallel with the second plurality of parity check values.

BRIEF DESCRIPTION OF THE FIGURES

The above and other aspects and advantages of the invention will beapparent upon consideration of the following detailed description, takenin conjunction with the accompanying drawings, in which like referencecharacters refer to like parts throughout, and in which:

FIG. 1 is a simplified block diagram of a parallel LDPC error-correctingcommunications or storage system;

FIG. 2 is a simplified block diagram that illustrates the generation ofa codeword using a parallel LDPC encoder;

FIG. 3 is an illustrative parity check matrix and illustrative 8×8circulant matrices;

FIG. 4 shows the illustrative parity check matrix of FIG. 3 divided intothree parity check sub-matrices; and

FIG. 5 is a simplified block diagram of a matrix-vector multiplicationunit of a parallel LPDC encoder;

FIG. 6 is a simplified block diagram of a bitwise-XOR unit of a parallelLPDC encoder;

FIG. 7 is a simplified block diagram that illustrates the parallelrecursion operations of a parallel LPDC encoder; and

FIG. 8 is a flowchart of a process for recursively computing paritycheck symbols in parallel.

DETAILED DESCRIPTION OF THE DISCLOSURE

FIG. 1 is a simplified and illustrative block diagram of digitalcommunications or storage system 100 that can employ the disclosedtechnology. System 100 may include parallel LDPC encoder 106, modulator108, demodulator 112, LDPC decoder 114, and optionally outer encoder 104and outer decoder 116. In some embodiments, system 100 may be anysuitable communications system that is used to transmit message 102 froma source to a destination. In other embodiments, system 100 may be asuitable storage system which is used to store and read back a messagefrom a storage medium. Message 102, sometimes referred to by thevariable b, may be any form of information or useful data that a userdesires to transmit or store, and can be in any suitable digital form(e.g., coded data, uncoded data, etc.).

Message 102 may be transmitted or stored using one or moreinformation-bearing signals. The signals may be transmitted or stored inany suitable transmission or storage medium or media, represented inFIG. 1 by channel 110. For example, channel 110 may be a wired orwireless medium through which the information-bearing signal travels, oran optical (e.g., a CD-ROM), magnetic (e.g., a hard disk), or electrical(e.g., FLASH memory or RAM) storage medium that stores theinformation-bearing signal. Due to random noise that may occur duringtransmission and storage, as well as the limited transmission or storagecapabilities of channel 110, the information-bearing signal may becorrupted or degraded while being transmitted or stored. Thus, thesignal received from channel 110 (e.g., by demodulator 112) may besubstantially different than the signal that was originally transmittedor stored (e.g., from modulator 108). To reliably transmit or storeinformation in channel 110, an effective transmitter for preparing andtransmitting message 102 may be needed, as well as a correspondingeffective receiver for accurately interpreting message 102 from areceived signal.

In FIG. 1, the transmitter in communications or storage system 100 isembodied by outer encoder 104 (if present), parallel LDPC encoder 106,and modulator 108. The receiver (described below) is embodied bydemodulator 112, LDPC decoder 114, and outer decoder 116 (if present).Outer encoder 104 and parallel LDPC encoder 106 may encode message 102into one or more codewords, sometimes referred to by the variable, c. Inparticular, outer encoder 104 may first encode message 102 using asuitable code, which may be a systematic code. For example, outerencoder 104 may encode message 102 using a Bose-Chaudhuri-Hocquenghem(BCH) or Reed-Solomon (RS) code of any suitable correction power.Parallel LDPC encoder 106 may then encode the resulting codeword intocodeword c. Parallel LDPC encoder 106 may operate concurrently orsubsequent to outer encoder 104 using a suitable low-density paritycheck (LDPC) code that is selected from among a plurality of availableLDPC codes.

Once parallel LDPC encoder 106 produces the codeword, modulator 108 mayconvert the codeword into an information-bearing signal for transmissionor storage in channel 110. Modulator 108 may operate using a modulationscheme with a signal constellation set of any suitable size anddimension. For example, modulator 108 may use a quadrature amplitudemodulation (QAM) scheme (e.g., 4QAM, 16QAM, 32QAM, etc.), a pulseamplitude modulation (PAM) scheme (e.g., 2 PAM, 4 PAM, 8 PAM, etc.), aphase shift keying (PSK) scheme (e.g., QPSK, 8 PSK, etc.), and/or aorthogonal frequency division multiplexing (OFDM) scheme. The type ofmodulation scheme used by modulator 108 may be selected and implementedbased on the properties of channel 110.

Demodulator 112 may receive an altered version of theinformation-bearing signal transmitted or stored by modulator 108.Demodulator 112 may then convert the information-bearing signal backinto a digital sequence using the same modulation scheme as that ofmodulator 108. Demodulator 112 therefore produces a hard-bit or soft-bitestimate of the codeword, that is decoded by LDPC decoder 114 and outerdecoder 116. LDPC decoder 114 and outer decoder 116 may decode theestimated codeword using the same LDPC and outer code, respectively, asthose used by parallel LDPC encoder 106 and outer encoder 108 to producedecoded information 118. Thus, if the hard-bit or soft-bit estimate iswithin the correcting capability of the LDPC and outer codes employed bydecoders 114 and 116, decoded information 118 may be the same as message102.

As described above, communications or storage system 100 may or may notinclude outer encoder 104 and outer decoder 116. For purposes ofclarity, and not by way of limitation, the various embodiments disclosedherein will often be described as if no outer code is used. For example,various embodiments may be described in which an LDPC encoder directlyencodes user information (e.g., parallel LDPC encoder 106 directlyencoders message 102). However, it should be understood that any of thedisclosed embodiments of an LDPC encoder may instead encode the outputof an outer encoder.

FIG. 2 illustrates the generation of a codeword, c, from message, b,using parallel LDPC encoder 206. LDPC codes are systematic code. An N,KLDPC code is a code in which K message bits are encoded by appending N−Kparity check bits to create a codeword having N bits. As illustrated inFIG. 2, K message bits, b₀ . . . b_(K-1), are provided to parallel LDPCencoder 206, which calculates parity check bits, p₀ . . . p_(N-K-1). Ncodeword bits, c, are generated by combining the K message bits, b, andthe N−K parity check bits, p, as shown by equation 201. The code rate ofan LDPC code represents the ratio of the number of message bits, b, tothe number of codeword bits, c. For example, an LDPC code with a coderate of 5/6 will produce 1944 codeword bits (N=1944) from 1620 messagebits (K=1620).

FIG. 3 shows an illustrative parity check matrix 301 that that may beemployed by parallel LDPC encoder 106 (FIG. 1) and LDPC decoder 114(FIG. 1) of system 100 (FIG. 1). However, it should be understood thatparallel LDPC encoder 106 and LDPC decoder 114 may use any othersuitable LDPC code instead of or in addition to parity check matrix 301.Parity check matrix 301 is a quasi-cyclic (QC) parity check matrix. A QCparity check matrix is a parity check matrix which is made up ofsub-matrices which are derived from permutations of the columns of anidentify matrix. These sub-matrices are sometimes referred to ascirculants. For example, in FIG. 3, each entry in parity check matrix301 represents an S×S circulant, where S=81. According to the IEEE802.11n standards, S may be 27, 54, or 81. Each circulant in paritycheck matrix 301 may be an S×S zero matrix (e.g., matrix of all zeros),an S×S identity matrix, or an S×S identity matrix shifted by someamount. Therefore, a parity check matrix may be represented in the formshown in FIG. 3, in which each entry representing a circulant is anumber between −1 and 80 to indicate a zero matrix (in the case of a −1)or the amount that an identity matrix is shifted. Circulants 302 areillustrative circulants derived from an 8×8 identity matrix. Circulant302 a represents an 8×8 identity matrix, circulant 302 b represents an8×8 identity matrix that has been shifted by two positions, andcirculant 302 c represents an 8×8 identity matrix that has been shiftedby five positions. This compressed representation of a quasi-cyclicparity check matrix shown in FIG. 3 allows a QC-LDPC coding system, suchas that illustrated in FIG. 1, to store a QC parity check matrix usingless memory than would be required to store all of the bit values of anon-QC LDPC parity check matrix.

With continued reference to FIG. 3, illustrative parity check matrix 301is a matrix with 4×24 circulants, where each circulant is an 81×81matrix. Thus, parity check matrix 301 is actually a 324×1994 paritycheck matrix. More generally, parity check matrix 301 is a (N−K)×Nmatrix where N=1944 and K=1620 with a circulant size S=81.

The generation of parity check bits, p, may be illustrated withreference to FIG. 4. It can be seen that parity check matrix 409 is thesame as parity check matrix 301 of FIG. 3. Parity check matrix 409 maybe divided into three sub-matrices, H_(A) 410, ρ 411, and H_(B) 412. Thedimensions of these sub-matrices are illustrated by generalized paritycheck matrix 401. Parity check matrix 401 is an N−K×N matrix. Sub-matrixH_(A) 402 is an N−K×K matrix, sub-matrix ρ 403 is an N−K×S matrix, andsub-matrix H_(B) 404 is an N−K×N−K-S matrix. The properties of thesesub-matrices are shown by generalized parity check matrix 405. LetM=(N−K)/S or equivalently the number of circulant rows in the paritycheck matrix (for example, in the illustrated parity check matrix 410 ofFIG. 4, M=4). Let T=K/S (i.e., 20) or equivalently the number ofcirculant columns in sub-matrix H_(B) 404. Sub-matrix H_(A) 406 is madeup of M×T circulants. Sub-matrix ρ 403 is a vector of M circulants,where the sum of the elements in sub-matrix ρ 403 is equal to theidentity matrix. Sub-matrix H_(B) 404 is a diagonal matrix made up ofM×M−1 circulants having the illustrated form.

An LPDC codeword c satisfies the relationship:y=Hc ^(T)=0  (EQ. 1),where H is a parity check matrix. Codeword, c, can be divided into amessage vector b and a parity check vector p. Parity check vector p canbe written as:p=[q ₀ q ₁ . . . q _(m-1)]  (EQ. 2),where each parity check sub-vector q_(i) is a 1×S vector. As shown inFIG. 4, parity check matrix H can be divided into sub-matrices H_(A), ρ,and H_(B). EQ. 1 can therefore be rewritten as:y=[H _(A) ρH _(B) ][bp] ^(T)=0=H _(A) b ^(T)+ρ(q ₀)^(T) +H _(B) [q ₁ q ₂ . . . q _(S-1)]^(T)=0  (EQ.3).Let H_(A)b^(T)=[r₀ r₁ . . . r_(N-1)]^(T), where each sub-vector r_(i) isa 1×S vector. As described above, sub-matrix ρ is defined such that thesum of the elements of the matrix are equal to the identity matrix(i.e., Σ_(i)h_(i)=I_(S×S)). Therefore, by multiplying EQ. 3 by ablock-row matrix, each block-element of which is an identity matrix, itcan be seen that:Σ_(i) r _(i) =q ₀  (EQ. 4).From this equation (EQ. 4), it can be seen that the first parity checksub-vector, q₀, can be calculated from the r vector. The remainingparity check sub-vectors [q₁ q₂ q_(M-1)] can be calculated recursivelyas follows:1) r ₀ ^(T) +h ₀ q ₀ ^(T) +q ₁ ^(T)=0→q ₁ T=r ₀ ^(T) +h _(O) q ₀ ^(T)r ₁ ^(T) +h ₁ q _(O) ^(T) +q ₁ ^(T) +q ₂ ^(T)=0→q ₂ ^(T) =r ₁ ^(T) +h ₁q _(O) ^(T) +q ₁ ^(T). . .r _(k) ^(T) +h _(k) q ₀ ^(T) +q _(k) ^(T) +q _(k+1) ^(T)=0→q _(k+1) ^(T)=r _(k) ^(T) +h _(k) q ₀ ^(T) +q _(k) ^(T),when k≠0 and k≠M−1.2) r _(M-1) ^(T) +h _(M-1) q ₀ ^(T) +q _(M-1) ^(T)=0→q _(M-1) ^(T) =r_(M-1) ^(T) +h _(M-1) q _(O) ^(T)   (EQ. 5).

As described above, the parity check matrix for the LDPC code is made upof S×S dimension circulant sub-matrixes H_(ij)=P_(n) that may be derivedfrom the identity matrix by rotating the rows or columns by i. Ifb_(j)=[x_(jS+S−n), . . . x_(jS+S−1), x_(jS), x_(jS+1), . . .x_(jS+S−n+1)], the computation of H_(A)b may be performed using:

$\begin{matrix}{{H_{A}b} = {{\begin{bmatrix}H_{0,0} & \ldots & H_{0,{T - 1}} \\H_{1,0} & \ldots & H_{1,{T - 1}} \\\vdots & \; & \vdots \\H_{{M - 1},0} & \ldots & H_{{M - 1},{T - 1}}\end{bmatrix}\left\lbrack \begin{matrix}{\overset{\_}{b}}_{0} \\{\overset{\_}{b}}_{1} \\\vdots \\{\overset{\_}{b}}_{T - 1}\end{matrix} \right\rbrack} = {\quad{\left\lbrack {{{\underset{\_}{H}}_{0}{\overset{\_}{b}}_{0}} + {{\underset{\_}{H}}_{1}{\overset{\_}{b}}_{1}} + \ldots + {{\underset{\_}{H}}_{T - 1}{\overset{\_}{b}}_{T - 1}}} \right\rbrack,}}}} & \left( {{EQ}.\mspace{14mu} 6} \right)\end{matrix}$where

${\underset{\_}{H}}_{i} = {\begin{bmatrix}H_{0,i} \\\vdots \\H_{{M - 1},i}\end{bmatrix}.}$

FIG. 5 is a simplified and illustrative block diagram 500 of a portionof a parallel LDPC encoder such as parallel LDPC encoder 106 of FIG. 1.Block diagram 500 is an illustrative matrix-vector multiplication unitfor calculating the vector multiplication H_(A)b^(T) based on EQ. 6. Inparticular, M circular buffers 501 may be used to calculate the elementsof the N−K×1 column vector H _(j) b _(j). The M circular buffers 501{BUF[0], BUF[1], BUF[M−1]} each can store S bits. If there are K messagebits to be encoded, the K message bits may be divided into T blocks ofsize S. In one embodiment, the K message bits may be processed asfollows:

-   -   1. Initialize the contents of circular buffers 501 to zero.    -   2. For every block j of S message bits:        -   a) Initialize pointers PTR[i] for BUF[i] to n=h_(ij).        -   b) XOR incoming message bit, b_(j), with the current            contents of buffer at the location pointed to by PTR[i] and            write back the result of the XOR operation to the same            buffer location. This operation may be performed for each            circular buffer 501.        -   c) Increment PTR[i]. Buffers 501 are circular, so the            pointers will wrap around to 0 after reaching the value S−1.            After all T blocks of S bits are processed in this manner            (i.e., K bits), the contents of circular buffers 501 will            contain the result of vector multiplication H_(A)b^(T)=[r₀            r₁ . . . r_(M-1)]^(T). This matrix-vector multiplication            unit shown in FIG. 5 represents one suitable approach for            calculating the vector multiplication H_(A)b^(T). It should            be understood that this multiplication may be performed            using other suitable hardware implementations or using            software running on any suitable hardware processor.

FIG. 6 is a simplified and illustrative block diagram 600 of anotherportion of a parallel LDPC encoder such as parallel LDPC encoder 106 ofFIG. 1. Block diagram 600 represents one illustrative approach forcalculating a first parity check sub-vector, q₀, from the r vector. Ther vector may, for example, be calculated using the process describedwith respect to FIG. 5. As shown by EQ. 4:q ₀ [k]=(Σ_(i) r _(i) [k])  (EQ. 7),where k={0, 1, . . . , S−1} is the bit index. This calculation may beperformed using a bitwise-XOR operation illustrated by BITWISE-XOR 602.BITWISE-XOR 602 receives sub-vectors {r₀ r₁ . . . r_(M-1)} from circularbuffers 601. Circular buffers 601 may be same as circular buffers 501after the vector multiplication H_(A)b^(T) described in FIG. 5 iscomplete. The result of the bitwise-XOR operation, q₀, is stored inbuffer 603. Simplified block diagram 600 represents one suitableapproach for calculating the sum of sub-vectors {r₀ r₁ . . . r_(M-1)}.It should be understood that this calculations may be performed usingother suitable hardware implementations or using software running on anysuitable hardware processor.

After the first parity check sub-vector, q₀, is calculated, theremaining parity check sub-vectors, {q₁ q₂ . . . q_(M-1)}, may berecursively calculated based on EQ. 5 above. In particular, the paritycheck sub-vectors may be computed using a bitwise-XOR operation asfollows:q ₁ [i]=r ₀ [i]XOR(q ₀ h ₀ ^(T))[i],q _(M-1) [i]=r _(M-1) [i]XOR(q ₀ h _(M-1) ^(T))[i],q _(k) [i]=r _(k−1) [i]XORq _(k−1) [i]XOR(q ₀ h _(k−1) ^(T))[i],  (EQ.8).for k={1, 2, . . . , M−2}Parity check matrices 301 (FIG. 3) and 409 (FIG. 4) have the followingproperties:

-   -   h₀=h_(M-1)=P₁ (i.e., identity matrix shifted by 1),    -   h_(M/2)=I_(S×S), and    -   h_(k)=0 for all remaining values of k. These properties apply to        a category of LDPC codes that includes the LDPC codes proposed        for the IEEE 802.11n standards belong. Noting that        q₀[i]P₁=q₀[(i+1) modulo S], EQ. 8 can be simplified to:        q ₁ [i]=q ₀[(i+1)moduloS]XORr ₀ [i],        q _(M-1) [i]=q ₀[(i+1)moduloS]XORr _(M-1) [i],        q _(M/2) [i]=q ₀ [i]XORq _((M/2)-1) [i]XORr _((M/2)-1),        q _(k) [i]=q _(k−1) [i]XORr _(k−1),   (EQ. 9).        for all k={0, 1, . . . , M−1}, excluding k={1, M/2, M−1}        These equations (EQ. 9) can be rewritten as:        q ₁ [i]=q ₀[(i+1)moduloS]XORr ₀ [i],        q _(M-1) [i]=q ₀[(i+1)moduloS]XORr _(M-1) [i],        q _(k) [i]=q _(k−1) [i]XORr _(k−1), for k={1,2, . . . M/2−1}        q _(k−1) [i]=q _(k) [i]XORr _(k−1), for k={M/2+1, . . . , M−2}        q _(M/2) [i]=q ₀ [i]XORq _((M/2)-1) [i]XORr _((M/2)-1),        q _(k) [i]=q _(k−1) [i]XORr _(k−1)  (EQ. 10).        Using these equations (EQ. 10), parity check sub-vectors q₁ and        q_(M-1) may be calculated based on first parity check        sub-vector, q₀. In an embodiment, q₁ and q_(M-1) may be        calculated in parallel. After parity check sub-vectors q₁ and        q_(M-1) are calculated, the remaining parity check sub-vectors,        may be recursively calculated in two parallel sets: S₁={q₂, . .        . , q_(M/2−1)} and S₂={q_(M/2+1), . . . , q_(M-2)}. By        calculating the parity check sub-vectors in parallel, the time        required to calculate these vectors may be cut in half. The        elements of S₁ may be computed in the following order: q₂, q₃, .        . . , q_(M/2−1), q_(M/2). The elements of S₂ may be computed in        the following order: q_(M-2), q_(M-3), . . . , q_(M/2+1). These        steps are illustrated graphically in FIG. 7.

FIG. 7 is a simplified and illustrative block diagram 700 of a parallelLDPC encoder such as parallel LDPC encoder 106 of FIG. 1. Circularbuffers 701 may be used to calculate the vector multiplicationH_(A)b^(T). Circular buffers 701 may perform this vector multiplicationin the same manner as described above with respect to FIG. 5. The outputof circular buffers 701 is vector r. After the vector multiplicationH_(A)b^(T) is complete, parity check vector p=[q₀ q₁ . . . q_(M-1)]^(T)can be calculated from a series of bitwise-XOR operations 702. First,parity check sub-vector q₀ may be calculated using bitwise-XOR operation707. Then, parity check sub-vectors q₁ and q_(M-1) may be calculated, inparallel, from parity check sub-vector q₀ using bitwise-XOR operations703 and 705. As shown in FIG. 7, the remaining parity check sub-vectors{q₂ . . . q_(M-2)} may also be computed in parallel pairs (q₂ andq_(M-2), q₃ and q_(M-3), etc.) using bitwise-XOR operations untilreaching the final parity check sub-vector q_(M/2). In order to simplifythe illustration of FIG. 7, only the first few bitwise-XOR operations(703, 704, 705, 706, and 707) and their respective inputs areillustrated. The remaining bitwise-XOR operations may be performed basedon EQ. 10. Furthermore, while the illustrative diagram of FIG. 7 showsseveral bitwise-XOR operations, it should be understood that all ofthese bitwise-XOR operations may be calculated using a selectable numberof XOR gates, e.g., only one or two bitwise XOR gates. For example,using only one bitwise-XOR gate, the output of the bitwise-XOR gate maybe fed back to its input along with a corresponding sub-vector valuer_(i) to generate the corresponding parity check vector sub-vector value{q₀ q₁ . . . q_(M-1)}. Using only two bitwise-XOR gates, a firstbitwise-XOR gate may be used to generate q₀ and an output of the firstbitwise-XOR gate may be iteratively fed into a second bitwise-XOR gatewith a second input chosen from {r₀ . . . r_(M-1)} to generate theremaining values in p, i.e., {q₁ . . . q_(M-1)}. Simplified blockdiagram 700 represents one suitable approach for calculating theparallel, recursive calculation of parity check vector p=[q₀ q₁ . . .q_(M-1)]^(T). It should be understood that this calculations may beperformed using other suitable hardware implementations or usingsoftware running on any suitable hardware processor.

Referring now to FIG. 8, an illustrative process is shown for computingparity symbols in parallel. The process of FIG. 8 may be executed by anysuitable LDPC encoder, such as parallel LDPC encoder 106 of FIG. 1. At801, values are calculated for the vector r. Vector r may be calculatedby multiplying incoming message bits, b, by parity check sub-matrixH_(A) (i.e., H_(A)b^(T)=r). FIG. 4 shows illustrative parity checkmatrices H and the division of these matrices H into sub-matrices H_(A),ρ, and H_(B). Vector r can be expressed as a series of M sub-vectorsr_(i), each having S elements. One illustrative approach for calculatingvector r is described above with respect to FIG. 5. At 802, the firstparity check sub-vector q₀ is calculated from vector r. As shown in EQ.4, parity check sub-vector q₀ is equal to the sum of sub-vectors r_(i).One illustrative approach for calculating parity check sub-vector q₀ isdescribed above with respect to FIG. 6. At 803, parity check sub-vectorsq_(i) are recursively calculated in parallel. For example, a first setof parity check sub-vectors {q₁, . . . , q_(M/2−1)} may be calculatedrecursively according to EQ. 10. A second set of parity checksub-vectors {q_(M-1), . . . , q_(M/2+1)} may be calculated reclusivelyaccording to EQ. 10, in parallel with the first set of parity checksub-vectors. This, parallel, recursive series of calculations may beillustrated above with respect to FIG. 7. Finally, at 804, the finalparity check sub-vector q_(M/2) is calculated. The overall process ofFIG. 8 may be implemented using the blocks schematically illustrated inFIG. 7. At the end of this process, a complete vector of parity checkbits p is generated, where p=[q₀, . . . , q_(M-1)]^(T). As shown in FIG.2, codeword c output by parallel LDPC encoder 106 (FIG. 1) includesmessage bits b and parity check bits p.

It is desirable to reduce the latency of LDPC encoders in order increaseencoding speed. The parallel LDPC encoding process of FIG. 8 may becompleted with a total latency as low as M/2+1. The calculation ofvector r at 801 may not have latency overhead because this calculationmay be performed as the message bit as received. The calculation of thefirst parity check sub-vector, q₀, (802) and the final parity checksub-vector, q_(M-1), (803) may each span one clock cycle of latency. Theparallel calculation of the remaining parity check sub-vectors q_(i) mayspan (M/2−1) clock cycles of latency. The total latency of this parallelLDPC encoding process (i.e., M/2+1) may be approximately half of thelatency of other LDPC encoding processes that do not calculate paritycheck values in parallel. Note that this latency is only for theencoding process. Other processes used to generate LDPC codewords suchas shortening, puncturing, and repetition may add additional processingoverheads.

The foregoing describes systems and methods for encoding a message usinga parallel LDPC encoder. Those skilled in the art will appreciate thatthe invention can be practiced by other than the described embodiments,which are presented for the purpose of illustration rather than oflimitation.

The above described embodiments of the present invention are presentedfor the purposes of illustration and not of limitation. Since manyembodiments of the invention can be made without departing from thespirit and scope of the invention, the invention resides in the claimshereinafter appended. Furthermore, the present invention is not limitedto a particular implementation. For example, one or more steps ofmethods described above may be performed in a different order orconcurrently and still achieve desirable results. The invention may beimplemented in hardware, such as on an application specific integratedcircuit (ASIC) or on a field-programmable gate array (FPGA). Theinvention may also be implemented in software running on any suitablehardware processor.

What is claimed is:
 1. A system for encoding a message using alow-density parity check (LDPC) check matrix, the system comprising:multiplication circuitry operative to multiply a portion of the LDPCcheck matrix with the message to obtain an encoding intermediate vector;and encoder circuitry operative to: recursively calculate a firstplurality of check values for the message based on the encodingintermediate vector; and recursively calculate a second plurality ofcheck values for the message based on the encoding intermediate vector.2. The system of claim 1, wherein the multiplication circuitry comprisesa plurality of circular buffers.
 3. The system of claim 2, wherein themultiplication circuitry is operative to: perform a plurality of logicoperations on the message and contents of the plurality of circularbuffers, and write results of the plurality of logic operations back tothe circular buffers.
 4. The system of claim 1, wherein the encodercircuitry is operative to: calculate an initial check value for themessage based on the encoding intermediate vector; recursively calculatethe first and the second plurality of check values for the message basedon the initial check value; and calculate a final check value for themessage based on the first and the second plurality of check values forthe message.
 5. The system of claim 4, wherein the encoder circuitryfurther comprises a bitwise-XOR unit for calculating the initial checkvalue for the message based on the encoding intermediate vector.
 6. Thesystem of claim 1, wherein the encoder circuitry comprises: a firstbitwise-XOR circuitry operative to recursively calculate the firstplurality of check values for the message; and a second bitwise-XORcircuitry operative to recursively calculate the second plurality ofcheck values for the message.
 7. The system of claim 1, wherein thefirst plurality of check values is calculated in parallel with thesecond plurality of check values.
 8. A transmission apparatuscomprising: the system of claim 1, wherein the transmission apparatus isoperative to encode the message into a codeword; and a modulatoroperative to modulate the codeword onto a channel.
 9. A method ofcalculating check values for a message using a low-density parity check(LDPC) check matrix, the method comprising: calculating a product of aportion of the LDPC check matrix with the message to obtain an encodingintermediate vector; determining a plurality of encoding intermediateproduct sub-vectors from the product of the portion of the LDPC checkmatrix with the message; combining the plurality of encodingintermediate product sub-vectors to compute a first parity checksub-vector for the message; and computing a second parity checksub-vector for the message by combining the computed first parity checksub-vector for the message and one of the plurality of encodingintermediate product sub-vectors.
 10. The method of claim 9, whereincalculating the product of the portion of the LDPC check matrix with themessage to obtain the encoding intermediate vector comprises performinga matrix-vector multiplication using a plurality of circular buffers.11. The method of claim 10, wherein performing the matrix-vectormultiplication comprises: performing a plurality of logic operations onthe message and contents of the plurality of circular buffers; andwriting results of the plurality of logic operations back to thecircular buffers.
 12. The method of claim 9, further comprising:calculating an initial check value for the message based on the encodingintermediate vector; recursively calculating a first and a secondplurality of check values for the message based on the initial checkvalue; and calculating a final check value for the message based on thefirst and the second plurality of check values for the message.
 13. Themethod of claim 12, wherein calculating the initial check value for themessage based on the encoding intermediate vector comprises performing abitwise-XOR operation.
 14. The method of claim 9, further comprising:recursively calculating a first plurality of check values for themessage by performing a first plurality of recursive bitwise-XORoperations; and recursively calculating a second plurality of checkvalues for the message by performing a second plurality of recursivebitwise-XOR operations, wherein the first and the second plurality ofcheck values for the message are calculated in parallel.
 15. The methodof claim 9, further comprising: recursively calculating respective onesof the first plurality of check values for the message based onrespective first sub-vectors of the encoding intermediate vector; andrecursively calculating respective ones of the second plurality of checkvalues for the message based on respective second sub-vectors theencoding intermediate vector.
 16. A non-transitory computer readablemedium storing computer executable instructions, which, when executed bya processor, causes the processor to carry out a method for: calculatinga product of a portion of an LDPC check matrix with the message toobtain an encoding intermediate vector; recursively calculating, usingencoder circuitry, a first plurality of check values for the messagebased on the encoding intermediate vector; and recursively calculating asecond plurality of check values for the message based on the encodingintermediate vector.
 17. The non-transitory computer readable medium ofclaim 16, wherein calculating the product of the portion of the LDPCcheck matrix with the message to obtain the encoding intermediate vectorcomprises performing a matrix-vector multiplication using a plurality ofcircular buffers.
 18. The non-transitory computer readable medium ofclaim 17, wherein performing the matrix-vector multiplication comprises:performing a plurality of logic operations on the message and contentsof the plurality of circular buffers; and writing results of theplurality of logic operations back to the circular buffers.
 19. Thenon-transitory computer readable medium of claim 16, the method furthercomprising recursively calculating the first and the second plurality ofcheck values for the message in parallel.
 20. The non-transitorycomputer readable medium of claim 16, the method further comprising:recursively calculating respective ones of the first plurality of checkvalues for the message based on respective first sub-vectors of theencoding intermediate vector; and recursively calculating respectiveones of the second plurality of check values for the message based onrespective second sub-vectors the encoding intermediate vector.